// 云函数入口文件
const cloud = require('wx-server-sdk')

// 初始化 cloud
cloud.init({
  env: cloud.DYNAMIC_CURRENT_ENV
})

const db = cloud.database()
const _ = db.command

// 云函数入口函数
exports.main = async (event, context) => {
  console.log('getUserInfo云函数接收到的事件:', event)
  
  const wxContext = cloud.getWXContext()
  const { OPENID } = wxContext
  
  try {
    const { action, userInfo } = event
    
    if (action === 'save') {
      // 保存用户信息
      const userData = {
        _id: OPENID,
        openId: OPENID,
        avatarUrl: userInfo.avatarUrl,
        nickName: userInfo.nickName,
        lastLoginTime: new Date(),
        createTime: new Date()
      }
      
      // 使用 set 方法，如果用户不存在则创建，存在则更新
      await db.collection('users').doc(OPENID).set({
        data: userData
      })
      
      return {
        success: true,
        message: '用户信息保存成功',
        data: userData
      }
    } else if (action === 'get') {
      // 获取用户信息
      const result = await db.collection('users').doc(OPENID).get()
      
      if (result.data) {
        return {
          success: true,
          message: '获取用户信息成功',
          data: result.data
        }
      } else {
        return {
          success: false,
          message: '用户信息不存在'
        }
      }
    } else if (action === 'getVoteRecords') {
      // 获取用户投票记录
      const voteResult = await db.collection('votes')
        .where({
          _openid: OPENID
        })
        .orderBy('voteTime', 'desc')
        .get()
      
      // 如果有投票记录，获取相关的活动信息
      let voteRecords = []
      if (voteResult.data && voteResult.data.length > 0) {
        // 获取所有相关的活动ID
        const activityIds = [...new Set(voteResult.data.map(vote => vote.activityId))]
        
        // 批量获取活动信息
        const activityResult = await db.collection('activities')
          .where({
            _id: _.in(activityIds)
          })
          .get()
        
        // 创建活动信息映射
        const activityMap = {}
        activityResult.data.forEach(activity => {
          activityMap[activity._id] = activity
        })
        
        // 统计每个活动的投票次数
        const voteCountMap = {}
        voteResult.data.forEach(vote => {
          const activityId = vote.activityId
          if (!voteCountMap[activityId]) {
            voteCountMap[activityId] = {
              count: 0,
              latestTime: vote.voteTime
            }
          }
          voteCountMap[activityId].count++
          if (vote.voteTime > voteCountMap[activityId].latestTime) {
            voteCountMap[activityId].latestTime = vote.voteTime
          }
        })
        
        // 构建投票记录数组
        let recordId = 1
        for (const [activityId, voteInfo] of Object.entries(voteCountMap)) {
          const activity = activityMap[activityId]
          if (activity) {
            voteRecords.push({
              id: recordId++,
              activityId: activityId,
              activityTitle: activity.title,
              voteTime: voteInfo.latestTime,
              voteCount: voteInfo.count
            })
          }
        }
        
        // 按时间倒序排列
        voteRecords.sort((a, b) => new Date(b.voteTime) - new Date(a.voteTime))
      }
      
      return {
        success: true,
        message: '获取投票记录成功',
        data: voteRecords
      }
    } else if (action === 'updateProfile') {
      // 更新用户资料
      if (!userInfo) {
        return {
          success: false,
          message: '缺少用户信息参数'
        }
      }
      
      const currentTime = new Date().toISOString().replace('T', ' ').substring(0, 19)
      
      // 更新用户信息
      const updateData = {
        nickName: userInfo.nickName,
        avatarUrl: userInfo.avatarUrl,
        lastLoginTime: currentTime
      }
      
      try {
        // 先检查用户是否存在
        const userResult = await db.collection('users').where({
          openId: OPENID
        }).get()
        
        if (userResult.data.length === 0) {
          // 用户不存在，创建新用户
          await db.collection('users').add({
            data: {
              openId: OPENID,
              ...updateData,
              createTime: currentTime,
              isAdmin: false
            }
          })
          console.log('新建用户并更新资料成功:', OPENID)
        } else {
          // 用户存在，更新资料
          await db.collection('users').where({
            openId: OPENID
          }).update({
            data: updateData
          })
          console.log('更新用户资料成功:', OPENID)
        }
        
        return {
          success: true,
          message: '更新用户资料成功',
          data: {
            ...updateData,
            openId: OPENID
          }
        }
      } catch (error) {
        console.error('更新用户资料失败:', error)
        return {
          success: false,
          message: '更新用户资料失败: ' + error.message,
          error: error.message
        }
      }
    } else if (action === 'checkAdmin') {
      // 检查管理员权限
      try {
        const userResult = await db.collection('users').where({
          openId: OPENID
        }).get()
        
        if (userResult.data.length === 0) {
          // 用户不存在，不是管理员
          return {
            success: true,
            message: '用户不存在',
            data: {
              isAdmin: false
            }
          }
        }
        
        const userData = userResult.data[0]
        const isAdmin = userData.isAdmin || false
        
        console.log('检查管理员权限:', OPENID, '结果:', isAdmin)
        
        return {
          success: true,
          message: '检查管理员权限成功',
          data: {
            isAdmin: isAdmin,
            openId: OPENID,
            nickName: userData.nickName
          }
        }
      } catch (error) {
        console.error('检查管理员权限失败:', error)
        return {
          success: false,
          message: '检查管理员权限失败: ' + error.message,
          error: error.message
        }
      }
    } else if (action === 'setAdmin') {
      // 设置管理员权限（仅供开发测试使用）
      const { targetOpenId, isAdmin } = event
      
      if (!targetOpenId) {
        return {
          success: false,
          message: '缺少目标用户openId参数'
        }
      }
      
      try {
        // 检查目标用户是否存在
        const userResult = await db.collection('users').where({
          openId: targetOpenId
        }).get()
        
        if (userResult.data.length === 0) {
          return {
            success: false,
            message: '目标用户不存在'
          }
        }
        
        // 更新用户的管理员权限
        await db.collection('users').where({
          openId: targetOpenId
        }).update({
          data: {
            isAdmin: isAdmin || false
          }
        })
        
        console.log('设置管理员权限成功:', targetOpenId, '权限:', isAdmin)
        
        return {
          success: true,
          message: '设置管理员权限成功',
          data: {
            targetOpenId: targetOpenId,
            isAdmin: isAdmin || false
          }
        }
      } catch (error) {
        console.error('设置管理员权限失败:', error)
        return {
          success: false,
          message: '设置管理员权限失败: ' + error.message,
          error: error.message
        }
      }
    } else {
      return {
        success: false,
        message: '未知操作类型'
      }
    }
  } catch (error) {
    console.error('getUserInfo云函数执行失败:', error)
    return {
      success: false,
      message: '操作失败，请重试',
      error: error.message
    }
  }
} 